home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
EnigmA Amiga Run 1996 June
/
EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso
/
earcd
/
comm1
/
s342q12.lha
/
msgnfmt.c
< prev
next >
Wrap
C/C++ Source or Header
|
1993-06-18
|
8KB
|
291 lines
/*
* MsgNFmt.c
*
* Prints a message in network format to blind target.
*/
/*
* history
*
* 89Apr27 HAW Bad interaction of routemail and Other Recipients
* 89Feb05 HAW Created.
*/
#include "ctdl.h"
/*
* contents
*
* prNetStyle() sends a msg in net format.
* NetCC() write out Other Recipient fields
* NetOverride() write out recipient override fields
*/
extern logBuffer logTmp; /* Person buffer */
extern int callSlot;
extern NetBuffer netBuf, netTemp;
extern SListBase MailForward;
extern CONFIG cfg; /* Lots an lots of variables */
extern MessageBuffer msgBuf;
/* void NetOverride(); */
char PrTransmit = TRUE; /* TRUE if writing to comm line */
/* FALSE if writing to disk */
int (*NetCharSource)(void) = getNetChar;
static char Overrode;
#define WriteCC WriteField
#define NetOverride WriteField
void WriteField();
#define CC 0
#define OVERRIDE 1
#define NONE 2
char FieldType;
/*
* NetPrintTarget allows us to blindly choose what to do with
* the output.
*/
void (*NetPrintTarget)(char *format, ...);
static char *GoingFor;
/*
* prNetStyle()
*
* This sends a msg in NET format. Target can be either disk or comm line.
*/
void prNetStyle(int NotMsgBase, int (*method)(int c), char GetMsg,
char *TargetSystem)
{
ForwardMail *address;
long val;
int c;
int (*SourceFn)(void);
char *rover;
extern char inNet;
GoingFor = TargetSystem;
/*
* Typically, we'll be getting a message to transmit from the
* message base. However, sometimes we don't. In those very rare
* cases we'll use the NetCharSource POINTER to find out where
* to get the stuff. This defaults to getNetChar, which is used
* to read virtual room messages, but is also occasionally used to
* read STadel routemail files to convert them to our route mail
* files.
*/
SourceFn = (NotMsgBase == 0) ? getMsgChar : NetCharSource;
/* fill in local node in origin fields if local message: */
if (!msgBuf.mborig[ 0])
strCpy(msgBuf.mborig, cfg.nodeId + cfg.codeBuf );
if (!msgBuf.mboname[0])
{
strCpy(msgBuf.mboname, cfg.nodeName + cfg.codeBuf);
strCpy(msgBuf.mbdomain, cfg.nodeDomain + cfg.codeBuf);
}
/* Convert # to 8-bit Citadel style for compatibility */
if (!msgBuf.mbsrcId[0])
{
val = atol(msgBuf.mbId);
sPrintf(msgBuf.mbsrcId, "%ld %ld",
(val & 0xFFFF0000l) >> 16, val & 0xFFFFl);
}
/* send header fields out: */
if (msgBuf.mbauth[ 0]) (*NetPrintTarget)("A%s", msgBuf.mbauth );
if (msgBuf.mbdate[ 0]) (*NetPrintTarget)("D%s", msgBuf.mbdate );
if (msgBuf.mbtime[ 0]) (*NetPrintTarget)("C%s", msgBuf.mbtime );
(*NetPrintTarget)("N%s", msgBuf.mboname);
(*NetPrintTarget)("O%s", msgBuf.mborig );
if (msgBuf.mbdomain[0])
(*NetPrintTarget)("X%s", msgBuf.mbdomain);
if (msgBuf.mbroom[ 0]) (*NetPrintTarget)("R%s", msgBuf.mbroom );
(*NetPrintTarget)("S%s", msgBuf.mbsrcId);
if (msgBuf.mbOther[0]) (*NetPrintTarget)("P%s", msgBuf.mbOther);
FieldType = CC;
RunList(&msgBuf.mbCC, WriteCC); /* write out Who Else fields */
Overrode = FALSE;
/*
* this if handles a piece of user-generated route mail
* in this situation there are no overrides and they must be
* generated from the mbCC list.
*/
if (!PrTransmit && inNet == NON_NET)
{
/*
* If mbOverride has stuff, this is caused by forwarding set up
* by one or more of the recipients of the mail. This may
* include mail initially locally forwarded ...
*/
if (GetFirst(&msgBuf.mbInternal) == NULL)
RunList(&msgBuf.mbCC, NetCC);
else
RunList(&msgBuf.mbInternal, NetCC);
}
/*
* this else translates to route mail being written to disk caused by
* mail forwarding during a network session -- that's the only case
* that'll satisfy this if. In this case the only override generation can
* come from the overrides already in place -- they are the only
* recipients on this system, so only they can generate a mail forwarding
* request.
*/
else if (!PrTransmit && inNet != NON_NET)
{
RunList(&msgBuf.mbOverride, NetCC);
RunList(&msgBuf.mbInternal, NetCC);
}
/*
* this else translates to network transmission of "normal" mail --
* that is, mail coming from the message base and therefore not
* bearing overrides. Any overrides must therefore be generated
* from the Who Else list.
*/
else if (!NotMsgBase && PrTransmit && inNet != NON_NET)
{
RunList(&msgBuf.mbCC, NetCC);
}
/*
* this else covers route mail about to be transmitted on the net.
* In this case the override fields already exist (from the originating
* system) so we just write them out, and everything's cool.
*/
else if (NotMsgBase && PrTransmit && inNet != NON_NET)
{
FieldType = OVERRIDE;
RunList(&msgBuf.mbOverride, NetOverride);
}
if (msgBuf.mbaddr[ 0] && (!PrTransmit || Overrode))
{
(*NetPrintTarget)("Q%s", msgBuf.mbaddr );
}
/*
* Basically, only do possible 'T' transformations if we're not outgoing
* route mail and we're not writing route mail to disk generated by
* incoming mail hitting a person with mail forwarding on.
*/
if (!(NotMsgBase && PrTransmit && inNet != NON_NET))
{
/*
* we use this control structure for backward compatability:
* systems which do not recognize the 'w' field of net messages.
*/
if (Overrode)
{
if (msgBuf.mbto[ 0])
(*NetPrintTarget)("T%s", msgBuf.mbto );
if (SearchList(&msgBuf.mbInternal, msgBuf.mbto) == NULL)
{
if (msgBuf.mbaddr[0])
sPrintf(msgBuf.mbtext, "%s@%s", msgBuf.mbto, msgBuf.mbaddr);
else
strCpy(msgBuf.mbtext, msgBuf.mbto);
NetCC(msgBuf.mbtext);
}
}
else
{
if (msgBuf.mbto[ 0])
{
address = SearchList(&MailForward, msgBuf.mbto);
(*NetPrintTarget)("T%s",
(address != NULL && strCmpU(address->System, GoingFor)
== SAMESTRING) ? address->Alias : msgBuf.mbto);
}
else (*NetPrintTarget)("T%s", msgBuf.mbto);
}
}
else if (msgBuf.mbto[0]) (*NetPrintTarget)("T%s", msgBuf.mbto);
FieldType = NONE;
RunList(&msgBuf.mbForeign, WriteField);
/* send message text proper: */
(*method)('M');
if (GetMsg)
{
do
{
c = (*SourceFn)();
if (c=='\n') c='\r';
if (!(*method)(c)) break;
}
while (c && c != -1);
}
else
{
for (rover = msgBuf.mbtext; *rover; rover++)
(*method)(*rover);
(*method)(0);
}
}
/*
* NetCC()
*
* This function is used to write out Other Recipient fields and sometimes
* to write override fields (only when system origin is this system, not
* another, however).
*/
void NetCC(char *d)
{
ForwardMail *address;
label person;
char system[(2 * NAMESIZE) + 2];
switch (SepNameSystem(d, person, system, &netTemp))
{
case IS_SYSTEM:
if (strCmpU(system, GoingFor) == SAMESTRING ||
strCmpU(LocalName(system), GoingFor) == SAMESTRING)
{
Overrode = TRUE;
(*NetPrintTarget)("w%s", person);
}
break;
case NOT_SYSTEM: /* forward to this system??? */
if ((address = SearchList(&MailForward, person)) != NULL &&
strCmpU(address->System, GoingFor) == SAMESTRING)
{
Overrode = TRUE;
(*NetPrintTarget)("w%s", address->Alias);
}
break;
}
}
#ifdef OLD_STYLE
/*
* WriteCC()
*
* This function is used to write out a 'W' field.
*/
static void WriteCC(char *d)
{
(*NetPrintTarget)("W%s", d);
}
/*
* NetOverride()
*
* This function is used to write out recipient override fields ('w').
*/
static void NetOverride(char *d)
{
(*NetPrintTarget)("w%s", d);
}
#else
#endif
void WriteField(char *d)
{
(*NetPrintTarget)((FieldType == OVERRIDE) ? "w%s" :
(FieldType == CC) ? "W%s" : "%s", d);
}